export const Bucket = "huan-xin-2-1313492122";
export const Region = "ap-shanghai";
import store from "@/store";

// 文件上传
export function uploadFileToCos(file, key) {
    let cos = store.state.cos.cos;
    console.log("upload", cos);
    return new Promise((resolve, reject) => {
        // 调用 COS SDK 的 putObject 方法
        cos.putObject({
                Bucket: Bucket,
                Region: Region,
                Key: "picture/" + key,
                Body: file,
            },
            function(err, data) {
                if (err) {
                    reject(err);
                } else {
                    resolve(data);
                }
            }
        );
    });
}
export function uploadMusicScoreToCos(file, key, prefix) {
    let cos = store.state.cos.cos;
    console.log("upload", cos);
    return new Promise((resolve, reject) => {
        // 调用 COS SDK 的 putObject 方法
        cos.putObject({
                Bucket: Bucket,
                Region: Region,
                Key: "musicScore/" + prefix + "/" + key,
                Body: file,
            },
            function(err, data) {
                if (err) {
                    reject(err);
                } else {
                    resolve(data);
                }
            }
        );
    });
}
// 分片上传

export function uploadBigFileToCos(file, key, onProgress) {
    return new Promise((resolve, reject) => {
        const fileSize = file.size;
        const chunkSize = 1024 * 1024; // 分片大小设置为 1MB
        const chunkCount = Math.ceil(fileSize / chunkSize); // 计算总分片数
        const cos = store.state.cos.cos; // 获取cos对象
        let uploadedChunks = 0; // 已上传的分片数

        // 初始化分片上传
        cos.uploadFile({
                Bucket: Bucket,
                /* 填入您自己的存储桶，必须字段 */
                Region: Region,
                /* 存储桶所在地域，例如ap-beijing，必须字段 */
                Key: "file/" + file.name,
                /* 存储在桶里的对象键（例如1.jpg，a/b/test.txt），必须字段 */
                Body: file,
                /* 必须，上传文件对象，可以是input[type="file"]标签选择本地文件后得到的file对象 */
                SliceSize: 1024 * 1024 * 5,
                /* 触发分块上传的阈值，超过5MB使用分块上传，非必须 */
                onTaskReady: function(taskId) {
                    /* 非必须 */
                    console.log(taskId);
                },
                onProgress: onProgress,
                onFileFinish: function(err, data, options) {
                    /* 非必须 */
                    console.log(options.Key + "上传" + (err ? "失败" : "完成"));
                },
            },
            function(err, data) {
                if (err) {
                    reject(err);
                } else {
                    resolve(data);
                }
                console.log(err || data);
            }
        );
    });
}
export function uploadVideoToCos(file, key, onProgress, onTaskReady) {
    return new Promise((resolve, reject) => {
        const fileSize = file.size;
        const chunkSize = 1024 * 1024; // 分片大小设置为 1MB
        const chunkCount = Math.ceil(fileSize / chunkSize); // 计算总分片数
        const cos = store.state.cos.cos; // 获取cos对象
        let uploadedChunks = 0; // 已上传的分片数

        // 初始化分片上传
        cos.uploadFile({
                Bucket: Bucket,
                /* 填入您自己的存储桶，必须字段 */
                Region: Region,
                /* 存储桶所在地域，例如ap-beijing，必须字段 */
                Key: "video/" + file.name,
                /* 存储在桶里的对象键（例如1.jpg，a/b/test.txt），必须字段 */
                Body: file,
                /* 必须，上传文件对象，可以是input[type="file"]标签选择本地文件后得到的file对象 */
                SliceSize: 1024 * 1024 * 5,
                /* 触发分块上传的阈值，超过5MB使用分块上传，非必须 */
                onTaskReady: onTaskReady,
                onProgress: onProgress,
                onFileFinish: function(err, data, options) {
                    /* 非必须 */
                    console.log(options.Key + "上传" + (err ? "失败" : "完成"));
                },
            },
            function(err, data) {
                if (err) {
                    reject(err);
                } else {
                    resolve(data);
                }
            }
        );
    });
}
// 终止分片上传
export function multipleAbort(currentTaskId) {
    let cos = store.state.cos.cos;

    return new Promise((resolve, reject) => {
        console.log("pause", currentTaskId);
        cos.pauseTask(currentTaskId);
    });
}
// 重新开始分片上传
export function restartUpload(currentTaskId) {
    let cos = store.state.cos.cos;

    return new Promise((resolve, reject) => {
        console.log("pause", currentTaskId);
        cos.restartTask(currentTaskId);
    });
}
// 取消上传任务
export function cancelUpload(currentTaskId) {
    let cos = store.state.cos.cos;

    return new Promise((resolve, reject) => {
        try {
            cos.cancelTask(currentTaskId);
            resolve();
        } catch (error) {
            reject(error);
        }
    });
}
// 删除文件
export function deleteUploadFile(key) {
    return new Promise((resolve, reject) => {
        let cos = store.state.cos.cos;
        console.log(key);
        cos.deleteObject({
                Bucket: Bucket,
                /* 填入您自己的存储桶，必须字段 */
                Region: Region,
                /* 存储桶所在地域，例如ap-beijing，必须字段 */
                Key: key,
                /* 存储在桶里的对象键（例如1.jpg，a/b/test.txt），必须字段 */
            },
            function(err, data) {
                if (err) {
                    reject(err);
                } else {
                    console.log(data);
                    resolve(data);
                }
            }
        );
    });
}
// 批量删除文件
export function deleteMultipleUploadFile(list) {
    return new Promise((resolve, reject) => {
        let cos = store.state.cos.cos;
        cos.deleteMultipleObject({
                Bucket: Bucket,
                /* 填入您自己的存储桶，必须字段 */
                Region: Region,
                /* 存储桶所在地域，例如ap-beijing，必须字段 */
                Objects: list,
            },
            function(err, data) {
                if (err) {
                    reject(err);
                } else {
                    resolve(data);
                }
            }
        );
    });
}
// 批量删除指定前缀下的所有文件
export function deleteMultipleUploadFileByPrefix(prefix = "") {
    return new Promise((resolve, reject) => {
        const cos = store.state.cos.cos;
        const listParams = {
            Bucket: Bucket,
            /* 填入您自己的存储桶，必须字段 */
            Region: Region,
            /* 存储桶所在地域，例如ap-beijing，必须字段 */
            Prefix: prefix,
            /* 指定要获取文件列表的前缀 */
        };

        // 获取指定前缀下的文件列表
        cos.getBucket(listParams, function(err, data) {
            if (err) {
                reject(err);
            } else {
                const fileList = data.Contents.map((item) => ({
                    Key: item.Key,
                }));

                // 删除文件列表中的文件
                const deleteParams = {
                    Bucket: Bucket,
                    /* 填入您自己的存储桶，必须字段 */
                    Region: Region,
                    /* 存储桶所在地域，例如ap-beijing，必须字段 */
                    Objects: fileList,
                    /* 要删除的文件列表 */
                };

                cos.deleteMultipleObject(deleteParams, function(err, data) {
                    if (err) {
                        reject(err);
                    } else {
                        resolve(data);
                    }
                });
            }
        });
    });
}

// 下载文件
export function downLoadFile(key) {
    let cos = store.state.cos.cos;
    return new Promise(function(resolve, reject) {
        cos.getObject({
                Bucket: Bucket /* 填入您自己的存储桶，必须字段 */ ,
                Region: Region /* 存储桶所在地域，例如 ap-beijing，必须字段 */ ,
                Key: key /* 存储在桶里的对象键（例如1.jpg，a/b/test.txt），必须字段 */ ,
                DataType: 'blob',
                onProgress: function(progressData) {
                    // console.log(JSON.stringify(progressData));
                },
            },
            function(err, data) {
                console.log(data);
                if (err) {
                    reject(err);
                } else {
                    console.log(data)
                    resolve(data);
                }
            }
        );
    });
}
// 下载文件夹
export function downLoadFileOrFolder(key) {
    let cos = store.state.cos.cos;

    return new Promise(function(resolve, reject) {
        cos.getBucket({
                Bucket: Bucket, // 填入您自己的存储桶，必须字段
                Region: Region, // 存储桶所在地域，例如 ap-beijing，必须字段
                Prefix: key, // 文件夹路径，例如 "folder/subfolder/"
            },
            function(err, data) {
                if (err) {
                    reject(err);
                } else {
                    const files = data.Contents;
                    const promises = [];

                    for (let i = 0; i < files.length; i++) {
                        const file = files[i];
                        const regex = /\/([^/]+)$/;
                        const match = file.Key.match(regex);
                        let fileKey = decodeURIComponent(match[1]);

                        promises.push(
                            new Promise(function(resolve, reject) {
                                cos.getObject({
                                        Bucket: Bucket, // 填入您自己的存储桶，必须字段
                                        Region: Region, // 存储桶所在地域，例如 ap-beijing，必须字段
                                        Key: decodeURIComponent(file.Key), // 存储在桶里的对象键，必须字段
                                        DataType: 'blob',
                                    },
                                    function(err, data) {
                                        if (err) {
                                            reject(err);
                                        } else {
                                            console.log("data", data, fileKey);
                                            // 将文件的key添加到返回的数据中
                                            const fileData = {
                                                key: fileKey,
                                                data: data,
                                            };
                                            resolve(fileData);
                                        }
                                    }
                                );
                            }));
                    }

                    Promise.all(promises).then(resolve).catch(reject);
                }
            }
        );
    });
}

// 批量下载文件
export function BatchDownloadFiles(keys, prefix) {
    let cos = store.state.cos.cos;
    let promises = [];

    keys.forEach((key) => {
        let promise = new Promise(function(resolve, reject) {
            cos.getObject({
                    Bucket: Bucket /* 填入您自己的存储桶，必须字段 */ ,
                    Region: Region /* 存储桶所在地域，例如 ap-beijing，必须字段 */ ,
                    Key: prefix +
                        "/" +
                        key /* 存储在桶里的对象键（例如1.jpg，a/b/test.txt），必须字段 */ ,
                    onProgress: function(progressData) {
                        console.log(JSON.stringify(progressData));
                    },
                },
                function(err, data) {
                    if (err) {
                        reject(err);
                    } else {
                        resolve(data);
                    }
                }
            );
        });

        promises.push(promise);
    });

    return Promise.all(promises);
}
// 获取所有对象
export function getAllFile() {
    let cos = store.state.cos.cos;

    return new Promise(function(resolve, reject) {
        cos.getBucket({
                Bucket: Bucket /* 填入您自己的存储桶，必须字段 */ ,
                Region: Region /* 存储桶所在地域，例如 ap-beijing，必须字段 */ ,
            },
            function(err, data) {
                console.log(data);
                if (err) {
                    reject(err);
                } else {
                    resolve(data);
                }
            }
        );
    });
}